package von.seiji.cn.imageT;

import cn.hutool.core.io.FileUtil;
import cn.hutool.core.io.IoUtil;
import cn.hutool.core.util.CharsetUtil;
import cn.hutool.core.util.URLUtil;
import com.google.common.collect.Lists;
import org.junit.Test;
import org.opencv.core.*;

import static org.opencv.highgui.HighGui.*;

import org.opencv.core.Point;
import org.opencv.imgcodecs.Imgcodecs;
import org.opencv.imgproc.Imgproc;
import org.opencv.imgproc.Moments;
import von.seiji.cn.MatUtil;
import von.seiji.cn.SelfUtil;
import von.seiji.cn.asset.Charsets;

import java.awt.*;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.net.MalformedURLException;
import java.net.URL;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Map;
import java.util.stream.Collectors;

/**
 * InputArray src：源图像
 * <p>
 * OutputArray dst：输出图像，与源图像大小一致
 * <p>
 * int adaptiveMethod：在一个邻域内计算阈值所采用的算法，有两个取值，分别为 ADAPTIVE_THRESH_MEAN_C 和 ADAPTIVE_THRESH_GAUSSIAN_C 。
 * <p>
 * ADAPTIVE_THRESH_MEAN_C的计算方法是计算出领域的平均值再减去第七个参数double C的值。
 * <p>
 * ADAPTIVE_THRESH_GAUSSIAN_C的计算方法是计算出领域的高斯均值再减去第七个参数double C的值。
 * <p>
 * int thresholdType：这是阈值类型，只有两个取值，分别为 THRESH_BINARY 和THRESH_BINARY_INV  具体的请看官方的说明，这里不多做解释。
 * <p>
 * int blockSize：adaptiveThreshold的计算单位是像素的邻域块，这是局部邻域大小，3、5、7等。
 * <p>
 * double C：这个参数实际上是一个偏移值调整量，用均值和高斯计算阈值后，再减或加这个值就是最终阈值。
 * ————————————————
 * 版权声明：本文为CSDN博主「小武~~」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
 * 原文链接：https://blog.csdn.net/weixin_40647819/article/details/90213858
 */

public class 综合阈值通道分离合并轮廓 {

    static {
        URL url = ClassLoader.getSystemResource("data/opencv_java454.dll");
        System.load(url.getPath());
    }

    /**
     * 分离通道
     */
    @Test
    public void lda9() throws MalformedURLException {
        String url = "https://gimg2.baidu.com/image_search/src=http%3A%2F%2Fc-ssl.duitang.com%2Fuploads%2Fblog%2F202008%2F29%2F20200829130145_anbvf.thumb.400_0.jpg&refer=http%3A%2F%2Fc-ssl.duitang.com&app=2002&size=f9999,10000&q=a80&n=0&g=0n&fmt=jpeg?sec=1644050338&t=a7da518629fb683155578685e80a9f2d";

        byte[] bytes = IoUtil.readBytes(URLUtil.getStream(new URL(url)));
        Mat source = Imgcodecs.imdecode(new MatOfByte(bytes), Imgcodecs.IMREAD_COLOR);
        ArrayList<Mat> mats = Lists.<Mat>newArrayList();
        Core.split(source, mats);
        mats.forEach(item -> {
            int i2 = mats.indexOf(item);
            Mat mat = new Mat(source.size(), source.type());
            for (int i = 0; i < mat.rows(); i++) {
                for (int i1 = 0; i1 < mat.cols(); i1++) {
                    mat.put(i, i1
                            , i2 == 0 ? 255 - item.get(i, i1)[0] : 0
                            , i2 == 1 ? 255 - item.get(i, i1)[0] : 0
                            , i2 == 2 ? 255 - item.get(i, i1)[0] : 0);
                }
            }
            Imgcodecs.imwrite("C:\\Users\\Administrator\\Desktop\\temp\\pic\\split" + i2 + ".jpg"
                    , mat);
        });

    }


    @Test
    public void createImage() {
        Mat mat = new Mat(500, 500, CvType.CV_64FC3);
        Color color = new Color(0);
        mat.setTo(new Scalar(color.getBlue(), color.getGreen(), color.getRed()));

        Mat mat1 = mat.clone();
        ArrayList<Mat> mats = Lists.<Mat>newArrayList();
        Core.split(mat, mats);
//        Mat t0 = mats.get(0);
//        t0.create(t0.size(), mat.type());
        /*imshow("T1", mats.get(1));
        imshow("T2", mats.get(2));*/

//        (0, 0, 255) -> (0, 0, 0)
        //彩虹
        ArrayList<Color> colors = Lists.newArrayList(
                Color.red, Color.orange, Color.yellow, Color.green, new Color(0, 127, 255), Color.blue, Color.pink
        );
        double sqrt = Math.sqrt(2 * 500 * 500);
        for (int i = 0; i < mat.rows(); i++) {
            for (int i1 = 0; i1 < mat.cols(); i1++) {
                int v = (int) (Math.sqrt(Math.pow(i, 2) + Math.pow(i1, 2)) / sqrt * colors.size());
                Color color1 = colors.get(v);
                mat1.put(i, i1
                        , color1.getBlue()
                        , color1.getGreen()
                        , color1.getRed());
            }
        }


        Imgcodecs.imwrite("C:\\Users\\Administrator\\Desktop\\temp\\pic\\zero2.jpg", mat1);
        System.out.println("+++++++++");
    }

    //填充矩形
    @Test
    public void ldka() {

        Mat mat = new Mat(500, 500, CvType.CV_64FC3);
        Imgcodecs.imwrite("C:\\Users\\Administrator\\Desktop\\temp\\pic\\000.jpg", mat);
        Imgproc.rectangle(mat, new Rect(100, 100, 100, 100), new Scalar(255, 253, 0), -1);
        Imgcodecs.imwrite("C:\\Users\\Administrator\\Desktop\\temp\\pic\\000.jpg", mat);

    }


    public static void main(String[] args) throws MalformedURLException {
        String url = "https://gimg2.baidu.com/image_search/src=http%3A%2F%2Fc-ssl.duitang.com%2Fuploads%2Fblog%2F202008%2F29%2F20200829130145_anbvf.thumb.400_0.jpg&refer=http%3A%2F%2Fc-ssl.duitang.com&app=2002&size=f9999,10000&q=a80&n=0&g=0n&fmt=jpeg?sec=1644050338&t=a7da518629fb683155578685e80a9f2d";

        byte[] bytes = IoUtil.readBytes(URLUtil.getStream(new URL(url)));
        Mat source = Imgcodecs.imdecode(new MatOfByte(bytes), Imgcodecs.IMREAD_COLOR);
        imshow("L0", source);
//        Mat source = Imgcodecs.imread("C:\\Users\\Administrator\\Desktop\\temp\\pic\\1641635862.jpg");


        Mat sourceG = new Mat();
        Imgproc.cvtColor(source, sourceG, Imgproc.COLOR_RGB2GRAY);
//        waitKey(10000);
        Imgproc.medianBlur(sourceG, sourceG, 5);
        imshow("U0", sourceG);

        Mat mat1 = new Mat();
        Imgproc.adaptiveThreshold(sourceG, mat1, 255, Imgproc.ADAPTIVE_THRESH_GAUSSIAN_C
                , Imgproc.THRESH_BINARY, 3, 2);
        imshow("U", mat1);

        ArrayList<MatOfPoint> objects = Lists.newArrayList();
        Imgproc.findContours(mat1, objects, new Mat()
                , Imgproc.RETR_TREE, Imgproc.CHAIN_APPROX_SIMPLE);
        System.out.println("objects.size() = " + objects.size());

        Mat mat = source.clone();
        Imgproc.drawContours(mat, objects, -1, new Scalar(0, 255, 255)
                , 1, Imgproc.LINE_AA);

        imshow("L", mat);
        waitKey(0);


    }

    /**
     * 单通道转3通道
     */
    @Test
    public void one2three() {
        Mat mat = new Mat(500, 500, CvType.CV_8UC1);
        Mat zeros = Mat.zeros(mat.size(), CvType.CV_8UC3);
        Core.merge(Lists.newArrayList(mat, mat, mat), zeros);
    }

    /**
     * 新年快乐
     */
    @Test
    public void rainbow() {
        char[] happiness = "祝你新年快乐！".toCharArray();
        Mat source = new Mat(100, 100, CvType.CV_8UC3);
        StringBuffer buffer = new StringBuffer();
        double sqrt = Math.sqrt(2) * source.cols();
        for (int i = 0; i < source.rows(); i++) {
            for (int i1 = 0; i1 < source.cols(); i1++) {
                int v = (int) (Math.sqrt(Math.pow(i, 2) + Math.pow(i1, 2)) / sqrt * happiness.length);
                buffer.append(happiness[v]);
            }
            buffer.append(Charsets.LINE_SEPARATOR_WINDOWS);
        }
        FileUtil.writeString(buffer.toString()
                , "C:\\Users\\Administrator\\Desktop\\temp\\pic\\num.txt", CharsetUtil.UTF_8);

    }

    @Test
    public void ascii() {
        char[] happiness = "happy new year !".toCharArray();
        Mat source = new Mat(200, 200, CvType.CV_8UC3);
        double sqrt = Math.sqrt(2) * source.cols();
        for (int i = 0; i < source.rows(); i += 5) {
            for (int i1 = 0; i1 < source.cols(); i1 += 5) {
                int v = (int) (Math.sqrt(Math.pow(i, 2) + Math.pow(i1, 2)) / sqrt * happiness.length);
                Imgproc.putText(source, String.valueOf(happiness[v]), new Point(i, i1)
                        , Imgproc.FONT_HERSHEY_SIMPLEX, .25d, Scalar.all(255)
                        , 0);
            }
        }
        Imgcodecs.imwrite("C:\\Users\\Administrator\\Desktop\\temp\\pic\\happier.jpg", source);

    }


    /**
     * 轮廓 1641655210
     */
    /**
     * 第一个参数：image，单通道图像矩阵，可以是灰度图，但更常用的是二值图像，一般是经过Canny、拉普拉斯等边
     * <p>
     * 缘检测算子处理过的二值图像；
     * <p>
     * <p>
     * <p>
     * 第二个参数：contours，定义为“vector<vector<Point>> contours”，是一个向量，并且是一个双重向量，向量
     * <p>
     * 内每个元素保存了一组由连续的Point点构成的点的集合的向量，每一组Point点集就是一个轮廓。
     * <p>
     * 有多少轮廓，向量contours就有多少元素。
     * <p>
     * <p>
     * <p>
     * 第三个参数：hierarchy，定义为“vector<Vec4i> hierarchy”，先来看一下Vec4i的定义：
     * <p>
     * typedef    Vec<int, 4>   Vec4i;
     * <p>
     * Vec4i是Vec<int,4>的别名，定义了一个“向量内每一个元素包含了4个int型变量”的向量。
     * <p>
     * 所以从定义上看，hierarchy也是一个向量，向量内每个元素保存了一个包含4个int整型的数组。
     * <p>
     * 向量hiararchy内的元素和轮廓向量contours内的元素是一一对应的，向量的容量相同。
     * <p>
     * hierarchy向量内每一个元素的4个int型变量——hierarchy[i][0] ~hierarchy[i][3]，分别表示第
     * <p>
     * i个轮廓的后一个轮廓、前一个轮廓、父轮廓、内嵌轮廓的索引编号。如果当前轮廓没有对应的后一个
     * <p>
     * 轮廓、前一个轮廓、父轮廓或内嵌轮廓的话，则hierarchy[i][0] ~hierarchy[i][3]的相应位被设置为
     * <p>
     * 默认值-1。
     * <p>
     * <p>
     * <p>
     * 第四个参数：int型的mode，定义轮廓的检索模式：
     * <p>
     * <p>
     * <p>
     * 取值一：CV_RETR_EXTERNAL只检测最外围轮廓，包含在外围轮廓内的内围轮廓被忽略
     * <p>
     * <p>
     * <p>
     * 取值二：CV_RETR_LIST   检测所有的轮廓，包括内围、外围轮廓，但是检测到的轮廓不建立等级关
     * <p>
     * 系，彼此之间独立，没有等级关系，这就意味着这个检索模式下不存在父轮廓或内嵌轮廓，
     * <p>
     * 所以hierarchy向量内所有元素的第3、第4个分量都会被置为-1，具体下文会讲到
     * <p>
     * <p>
     * <p>
     * 取值三：CV_RETR_CCOMP  检测所有的轮廓，但所有轮廓只建立两个等级关系，外围为顶层，若外围
     * <p>
     * 内的内围轮廓还包含了其他的轮廓信息，则内围内的所有轮廓均归属于顶层
     * <p>
     * <p>
     * <p>
     * 取值四：CV_RETR_TREE， 检测所有轮廓，所有轮廓建立一个等级树结构。外层轮廓包含内层轮廓，内
     * <p>
     * 层轮廓还可以继续包含内嵌轮廓。
     * <p>
     * <p>
     * <p>
     * 第五个参数：int型的method，定义轮廓的近似方法：
     * <p>
     * <p>
     * <p>
     * 取值一：CV_CHAIN_APPROX_NONE 保存物体边界上所有连续的轮廓点到contours向量内
     * <p>
     * <p>
     * <p>
     * 取值二：CV_CHAIN_APPROX_SIMPLE 仅保存轮廓的拐点信息，把所有轮廓拐点处的点保存入contours
     * <p>
     * 向量内，拐点与拐点之间直线段上的信息点不予保留
     * <p>
     * <p>
     * <p>
     * 取值三和四：CV_CHAIN_APPROX_TC89_L1，CV_CHAIN_APPROX_TC89_KCOS使用teh-Chinl chain 近
     * <p>
     * 似算法
     * <p>
     * <p>
     * <p>
     * 第六个参数：Point偏移量，所有的轮廓信息相对于原始图像对应点的偏移量，相当于在每一个检测出的轮廓点上加
     * <p>
     * 上该偏移量，并且Point还可以是负值！
     */
    @Test
    public void fdlsak() {
        Mat origin = Imgcodecs.imread("C:\\Users\\Administrator\\Desktop\\temp\\pic\\1641655210.jpg");
        imshow("L0", origin);
        Mat imread = origin.clone();
        Imgproc.cvtColor(imread, imread, Imgproc.COLOR_RGB2GRAY);
        imshow("L", imread);
        Mat gray = new Mat(imread.size(), imread.type());
        int thresh_size = (100 / 4) * 2 + 1; //自适应二值化阈值
        Imgproc.adaptiveThreshold(imread, gray, 255, Imgproc.ADAPTIVE_THRESH_GAUSSIAN_C
                , Imgproc.THRESH_BINARY_INV, thresh_size, thresh_size / 3);
//        Imgproc.threshold(imread, gray, 127, 255, Imgproc.THRESH_BINARY_INV);
        imshow("L1", gray);
        ArrayList<MatOfPoint> points = Lists.<MatOfPoint>newArrayList();
        Imgproc.findContours(gray, points, new Mat(), Imgproc.RETR_EXTERNAL, Imgproc.CHAIN_APPROX_SIMPLE);
        Mat contours = new Mat(imread.size(), CvType.CV_8UC3);
        contours.setTo(Scalar.all(0));
        Imgproc.drawContours(contours, points, Imgproc.FILLED, Scalar.all(255)
                , -1, Imgproc.LINE_AA);
        imshow("L2", contours);

        Mat mat = new Mat(imread.size(), CvType.CV_8UC3);
        mat.setTo(new Scalar(255, 255, 0));
        origin.copyTo(mat, contours);
        imshow("L3", mat);
        Imgcodecs.imwrite("C:\\Users\\Administrator\\Desktop\\temp\\pic\\1641655210_mat.jpg", mat);


        waitKey(0);

    }

    /**
     * 看我如何用阈值反转，嘻嘻
     */
    @Test
    public void dlskajf() {
        Mat origin = Imgcodecs.imread("C:\\Users\\Administrator\\Desktop\\temp\\pic\\yaya.jpg");
        imshow("L", origin);
        Mat clone1 = origin.clone();
        Imgproc.cvtColor(origin, clone1, Imgproc.COLOR_RGB2GRAY);
        Imgproc.GaussianBlur(clone1, clone1, new Size(3, 3), 1, 1);
        imshow("L1", clone1);
        Mat clone = origin.clone();
        Imgproc.threshold(clone1, clone, 250, 255, Imgproc.THRESH_BINARY_INV);
        imshow("L2", clone);
        ArrayList<MatOfPoint> points = Lists.<MatOfPoint>newArrayList();
        Imgproc.findContours(clone, points, new Mat(), Imgproc.RETR_EXTERNAL, Imgproc.CHAIN_APPROX_NONE);
        // ------------------------------------------------------------------
        System.out.println("points.size() = " + points.size());

        System.out.println("总像素点数：" + (origin.rows() * origin.cols()));
        points.forEach(item -> {
            System.out.println("+++++++++++++++++++++++++++++++++++++++++++++++++");
            double v = Imgproc.contourArea(item);
            System.out.println("面积 = " + v);
            MatOfPoint2f point2f = new MatOfPoint2f();
            item.convertTo(point2f, CvType.CV_32F);
            double v1 = Imgproc.arcLength(point2f, true);
            System.out.println("周长 = " + v1);
            System.out.println("比较：" + item.toArray().length);
            Moments moments = Imgproc.moments(item);
            System.out.println("moments = " + moments);
            Point circle = new Point(moments.m10 / moments.m00, moments.m01 / moments.m00);
            System.out.println("中心："
                    + circle);
            Imgproc.circle(origin, circle, 7, new Scalar(0, 0, 255), -1);
        });

        // ------------------------------------------------------------------

        Mat mat = new Mat(origin.size(), CvType.CV_8U);
        mat.setTo(Scalar.all(0));
        Imgproc.drawContours(mat, points, Imgproc.FILLED, Scalar.all(255), Imgproc.FILLED);
        imshow("L3", mat);
        Mat mat1 = new Mat();
        mat1.create(origin.size(), origin.type());
        mat1.setTo(new Scalar(0, 0, 255));
        origin.copyTo(mat1, mat);
        imshow("L4", mat1);


        waitKey(0);
    }

}
